home *** CD-ROM | disk | FTP | other *** search
/ Turnbull China Bikeride / Turnbull China Bikeride - Disc 1.iso / ARGONET / PD / SOUND / REPLAYER.SPK / c / header < prev    next >
Text File  |  1998-09-04  |  12KB  |  361 lines
  1.  
  2. /* header.c
  3.  
  4.    Replayer -- audio player
  5.    Copyright (c) 1997 Mark Seaborn <mseaborn@argonet.co.uk>
  6.  
  7.    This file provides the functions for reading in Replay file headers.
  8.    It should all be portable.
  9. */
  10.  
  11. #include <stdlib.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <ctype.h>
  15.  
  16. #include "replayer.h"
  17.  
  18.  
  19. /* Declarations */
  20.  
  21. static int split_soundtrack_line(char *line, char ***tracks);
  22. static int cache_header_info(const replayer_file *x_obj);
  23. static int read_catalogue_value(FILE *file, char end);
  24.  
  25.  
  26. /* Public functions for reading Replay headers. */
  27.  
  28. /* Returns the structure for the Replay header, making sure it has been
  29.    loaded first.  Returns zero for failure.
  30. */
  31. const replayer_header *replayer_get_header(const replayer_file *obj)
  32. {
  33.   if(!obj) return 0;
  34.  
  35.   cache_header_info(obj);
  36.   return obj->header;
  37. }
  38.  
  39. /* Returns the chunk catalogue for this file, ensuring it is loaded first.
  40.    Returns zero for failure.
  41. */
  42. const replayer_chunk_entry *replayer_get_chunk_catalogue(
  43.     const replayer_file *obj)
  44. {
  45.   if(!obj) return 0;
  46.  
  47.   cache_header_info(obj);
  48.   return obj->chunks;
  49. }
  50.  
  51.  
  52. /* Private functions for reading Replay headers. */
  53.  
  54. /* Generic line-reader function; better than fgets() as there is no
  55.    fixed-length buffer.  Returns 0 for failure, otherwise the line in
  56.    question (you must free it yourself).  Used by cache_header_info().
  57. */
  58. char *replayer_read_header_line(FILE *file)
  59. {
  60.   int size = 20;
  61.   char *line = malloc(size+1), *p = line;
  62.   if(!line) return 0;
  63.  
  64.   while(1) {
  65.     int c = fgetc(file);
  66.     if(c == EOF || c == '\n') break;
  67.     *p++ = c;
  68.  
  69.     /* Allocate some more buffer space if necessary. */
  70.     if((p - line + 2) >= size) {
  71.       char *old_ptr = line;
  72.       size += 20;
  73.       line = realloc(line, size+1);
  74.       if(!line) { return 0; }
  75.       p = p - old_ptr + line;
  76.     }
  77.   }
  78.   *p = 0;
  79.   /* Shrink the buffer to minimum size before returning it. */
  80.   return realloc(line, strlen(line)+1);
  81. }
  82.  
  83. int replayer_read_header_number(FILE *file)
  84. {
  85.   char *line = replayer_read_header_line(file);
  86.   if(line) {
  87.     int number = atoi(line);
  88.     free(line);
  89.     return number;
  90.   }
  91.   else return 0;
  92. }
  93.  
  94. /* This function parses header lines containing information about the Replay
  95.    file's soundtracks.  The sections are separated by |x, where x is the
  96.    soundtrack number.  Used by cache_header_info().  Returns -1 for failure.
  97.    You must free the array used yourself.
  98. */
  99. static int split_soundtrack_line(char *line, char ***tracks)
  100. {
  101.   /* i is the current track being written to;
  102.      max is the number of tracks in total. */
  103.   int i = 0, max = 1;
  104.   *tracks = malloc(sizeof(char*));
  105.   if(!*tracks) return -1;
  106.  
  107.   do {
  108.     char *next;
  109.     (*tracks)[i] = line;
  110.  
  111.     next = strchr(line, '|');
  112.     if(next) {
  113.       *next = 0;
  114.       i = atoi(next+1) - 1;    /* Set i to the next track number. */
  115.       if(i >= max) max = i+1;    /* Update max if necessary. */
  116.       *tracks = realloc(*tracks, sizeof(char*) * max);
  117.       if(!*tracks) return -1;
  118.  
  119.       line = next + 2;
  120.       while(*line == ' ' || *line == '\t') ++line;  /* Skip whitespace. */
  121.       continue;
  122.     }
  123.   } while(0);
  124.   return max;
  125. }
  126.  
  127. /* This functions reads an integer in the chunk catalogue from a file until
  128.    it reaches the given terminating character.  Used by cache_header_info().
  129.    Returns -1 for failure.
  130. */
  131. static int read_catalogue_value(FILE *file, char end)
  132. {
  133.   char buffer[20], *s = buffer;
  134.   while(1) {
  135.     int ch = fgetc(file);
  136.     while(ch == ' ') { ch = fgetc(file); }    /* Skip any whitespace */
  137.     if(ch == end || ch == '\n') break;        /* End loop */
  138.     if(ch == EOF) return -1;            /* Failure */
  139.     *s++ = ch;
  140.     if(s >= buffer+sizeof(buffer)) return -1;
  141.   }
  142.   *s = 0;
  143.   return atoi(buffer);
  144. }
  145.  
  146. /* Loads the header information from a Replay file; does nothing if it
  147.    hasn't been loaded already.  Returns 0 for a failure, !=0 for success.
  148. */
  149. static int cache_header_info(const replayer_file *x_obj)
  150. {
  151.   /* The object passed is const from the client's point of view, because
  152.      nothing changes for it.  However, we cast it because we've got to
  153.      add in the header if it's not loaded already. */
  154.   replayer_file *obj = (replayer_file *) x_obj;
  155.   int success = 0;
  156.  
  157.   /* If the header is loaded, so should the chunk catalogue,
  158.      and vice-versa. */
  159.   if(!obj->header || !obj->chunks) {
  160.     replayer_header *header = 0;
  161.     replayer_soundtrack_info *tracks = 0;
  162.     replayer_chunk_entry *chunks = 0;
  163.     FILE *file = 0;
  164.     char *line;
  165.  
  166.     /* Allocate some space to store the header info. */
  167.     header = malloc(sizeof(replayer_header));
  168.     if(!header) goto fail;
  169.  
  170.     /* Although we're reading textual bits of the file, it's probably
  171.        safer to open it as binary. */
  172.     file = fopen(obj->filename, "rb");
  173.     if(!file) goto fail;
  174.  
  175.     /* Skip the "ARMovie" line. */
  176.     while(1) {
  177.       int c = fgetc(file);
  178.       if(c == EOF || c == '\n') break;
  179.     }
  180.  
  181.     /* Read misc data. */
  182.     header->title = replayer_read_header_line(file);
  183.     header->date_and_copyright = replayer_read_header_line(file);
  184.     header->other_details = replayer_read_header_line(file);
  185.  
  186.     /* Read video information. */
  187.     header->video_type = replayer_read_header_line(file);
  188.     header->width = replayer_read_header_number(file);
  189.     header->height = replayer_read_header_number(file);
  190.     header->colour_depth = replayer_read_header_number(file);
  191.     header->fps = replayer_read_header_number(file);
  192.  
  193.     /* Read in the settings for each soundtrack.
  194.        This is slightly hairy because of the way the settings are
  195.        split across each line. */
  196.     {
  197.       /* Declare the variables we need. */
  198.       char **split;
  199.       int no_tracks, i;
  200.  
  201.       /* Read in the first line (sound type) and split it. */
  202.       line = replayer_read_header_line(file);
  203.       if(!line) goto fail;
  204.       no_tracks = split_soundtrack_line(line, &split);
  205.       if(no_tracks == -1) goto fail;
  206.       /* There are no soundtracks if a sound type of 0 is given. */
  207.       if(!atoi(split[0])) no_tracks = 0;
  208.  
  209.       /* Allocate the structures to store all the sound settings. */
  210.       tracks = malloc(sizeof(replayer_soundtrack_info) * no_tracks);
  211.       if(!tracks) goto fail;
  212.       header->no_soundtracks = no_tracks;
  213.       header->soundtracks = tracks;
  214.  
  215.       /* Read in the sound type values. */
  216.       for(i = 0; i < no_tracks; ++i) {
  217.         char *copied;
  218.         tracks[i].type_number = atoi(split[i]);
  219.  
  220.         if(tracks[i].type_number == 2) {
  221.           /* If this is a type 2 track, copy the driver leafname only. */
  222.           const char *from = split[i], *to;
  223.           while(*from != ' ' && *from) ++from;
  224.           while(*from == ' ') ++from;
  225.           to = from;
  226.           while(*to != ' ' && *to) ++to;
  227.           /* Allocate the storage to copy it. */
  228.           copied = malloc(to - from + 1);
  229.           if(!copied) goto fail;
  230.           /* should free other stuff here on failure too */
  231.           memcpy(copied, from, to - from);
  232.           copied[to - from] = 0;
  233.         }
  234.         else {
  235.           /* Otherwise, for type 1 tracks, copy the whole line. */
  236.           copied = malloc(strlen(split[i]) + 1);
  237.           if(!copied) goto fail;
  238.           /* other stuff should be freed here */
  239.           strcpy(copied, split[i]);
  240.         }
  241.         tracks[i].type = copied;
  242.       }
  243.       free(split);
  244.       free(line);
  245.  
  246.       /* Read the sample rate values. */
  247.       line = replayer_read_header_line(file);
  248.       if(!line) goto fail;
  249.       if(split_soundtrack_line(line, &split) == -1) goto fail;
  250.       for(i = 0; i < no_tracks; ++i) {
  251.         double rate = atof(split[i]);
  252.         if(rate < 256 && rate > 0)
  253.           rate = 1e6 / rate; /* Convert usec -> Hz. */
  254.         tracks[i].rate = rate;
  255.       }
  256.       free(split);
  257.       free(line);
  258.  
  259.       /* Read the numbers of sound channels (ie. stereo or mono)
  260.          and whether they are reversed or not. */
  261.       line = replayer_read_header_line(file);
  262.       if(!line) goto fail;
  263.       if(split_soundtrack_line(line, &split) == -1) goto fail;
  264.       for(i = 0; i < no_tracks; ++i) {
  265.         char *c;
  266.         tracks[i].channels = atoi(split[i]);
  267.         /* See below for bit about substrings in header. */
  268.         for(c=split[i]; *c; ++c) *c = tolower(*c);
  269.         tracks[i].reverse_channels = strstr(split[i], "rever") ? 1:0;
  270.       }
  271.       free(split);
  272.       free(line);
  273.  
  274.       /* Read the sound precision (ie. 8 or 16 bits), and whether the
  275.          sound is linear or unsigned, or whatever. */
  276.       line = replayer_read_header_line(file);
  277.       if(!line) goto fail;
  278.       if(split_soundtrack_line(line, &split) == -1) goto fail;
  279.       for(i = 0; i < no_tracks; ++i) {
  280.         char *c;
  281.         tracks[i].precision = atoi(split[i]);
  282.         /* The header format uses the system of looking for substrings
  283.            in this line to determine some sound format details.  However,
  284.            the ARMovie documentation disagrees about what the substrings
  285.            should be.  eg. "AE7doc" says "unsigned", whereas the example
  286.            in "ToUseSound" says "unsign".  To play it safe, I will use
  287.            the short versions, and be case insensitive. */
  288.         for(c=split[i]; *c; ++c) *c = tolower(*c);
  289.         tracks[i].linear_sound = strstr(split[i], "lin") ? 1:0;
  290.         tracks[i].unsigned_sound = strstr(split[i], "unsign") ? 1:0;
  291.         tracks[i].adpcm_sound = strstr(split[i], "adpcm") ? 1:0;
  292.         /* See the "reversed" substring above as well. */
  293.       }
  294.       free(split);
  295.       free(line);
  296.     }
  297.  
  298.     /* Read the rest of the header. */
  299.     header->frames_per_chunk = replayer_read_header_number(file);
  300.     header->no_chunks = replayer_read_header_number(file);
  301.     header->even_chunk_size = replayer_read_header_number(file);
  302.     header->odd_chunk_size = replayer_read_header_number(file);
  303.     header->chunk_catalogue = replayer_read_header_number(file);
  304.     header->sprite_offset = replayer_read_header_number(file);
  305.     header->sprite_size = replayer_read_header_number(file);
  306.     header->key_frames_offset = replayer_read_header_number(file);
  307.  
  308.     /* Read in the chunk catalogue.  This must be done last because we
  309.        have to just to a different place in the file to do it.
  310.        Remember, the number of chunks given in the header is one less
  311.        than in the catalogue. */
  312.     {
  313.       replayer_chunk_entry *c, *end;
  314.       int i, ch;
  315.  
  316.       chunks = malloc(replayer_chunk_entry_SIZE(header->no_soundtracks) *
  317.         (header->no_chunks + 1));
  318.       if(!chunks) goto fail;
  319.       c = chunks;
  320.       end = (replayer_chunk_entry *) ((char *) chunks +
  321.         replayer_chunk_entry_SIZE(header->no_soundtracks) *
  322.         (header->no_chunks + 1));
  323.  
  324.       /* Loop for each catalogue chunk entry. */
  325.       if(fseek(file, header->chunk_catalogue, SEEK_SET)) goto fail;
  326.       while(c < end) {
  327.         c->offset = read_catalogue_value(file, ',');
  328.         c->video_size = read_catalogue_value(file, ';');
  329.         for(i=0; i<header->no_soundtracks; ++i) {
  330.           c->sound_size[i] = read_catalogue_value(file, '|');
  331.           if(i == header->no_soundtracks-1) break;
  332.           /* Skip the number that follows the '|' until we
  333.              reach whitespace, for all but last soundtrack. */
  334.           do { ch = fgetc(file); } while(ch != EOF && ch != ' ');
  335.         }
  336.         c = (replayer_chunk_entry *) ((char *) c +
  337.         replayer_chunk_entry_SIZE(header->no_soundtracks));
  338.       }
  339.     }
  340.  
  341.     /* Finish successfully. */
  342.     obj->header = header;
  343.     obj->chunks = chunks;
  344.     success = 1;
  345.     goto finish;
  346.  
  347.     /* Finish after a failure. */
  348.   fail:
  349.     free(chunks);
  350.     free(tracks);
  351.     free(header);
  352.     /* Drop through to finish. */
  353.  
  354.   finish:
  355.     /* Tidy up (possibly after failure). */
  356.     if(file) fclose(file);
  357.     return success;
  358.   }
  359.   else return 1; /* Success */
  360. }
  361.